// --- 全局变量 ---
// 当前登录用户信息（从session获取）
let currentUser = null;

// 全局用户ID变量，供其他功能使用
window.CURRENT_USER_ID = null;

// 模拟文件数据
const mockFiles = [
    { name: '工作文档', type: 'folder', size: '-', date: '2024-01-15', icon: '📁' },
    { name: '项目资料', type: 'folder', size: '-', date: '2024-01-14', icon: '📁' },
    { name: '会议记录.pdf', type: 'document', size: '2.3MB', date: '2024-01-13', icon: '📄' },
    { name: '产品设计图.png', type: 'image', size: '1.8MB', date: '2024-01-12', icon: '🖼️' },
    { name: '演示视频.mp4', type: 'video', size: '45.2MB', date: '2024-01-11', icon: '🎥' },
    { name: '背景音乐.mp3', type: 'audio', size: '3.7MB', date: '2024-01-10', icon: '🎵' },
    { name: '数据报表.xlsx', type: 'document', size: '856KB', date: '2024-01-09', icon: '📊' },
    { name: '团队照片.jpg', type: 'image', size: '4.2MB', date: '2024-01-08', icon: '🖼️' }
];

// 导航路径映射配置
const pathMappings = {
    'home': '/home/index',
    'shares': '/shares/myShares',
    'trash': '/trash/index'
    // 文件类型过滤不通过路径映射，直接调用iframe内部函数
};

// 新增：当前页面标识（默认首页，切换页面时更新）
let currentPageType = 'home';

let filteredFiles = [...mockFiles];
let searchTimeout;

// --- 页面初始化 ---
// 这是唯一的初始化入口
document.addEventListener('DOMContentLoaded', function() {
    console.log('页面DOM加载完成，开始初始化...');

    // 检查登录状态
    checkLoginStatus();

    // 设置初始iframe路径
    const defaultPath = pathMappings['home'];
    if (defaultPath) {
        document.getElementById('contentIframe').src = defaultPath;
    }

    // 调用所有设置函数
    setupEventListeners();
    setupSearch();
    setupNavigation();
    setupFileTypesToggle();

    // 初始化显示存储使用情况
    refreshStorageInfo();

    // 由于你的文件列表被注释掉了，renderFileList()暂时不需要调用
    // renderFileList();

    // 添加键盘快捷键支持
    setupKeyboardShortcuts();

    // 初始化搜索功能
    setupSearchLogic();

    console.log('初始化完成！');
});

// --- 功能函数 ---

// --- 1. 新增搜索按钮聚焦函数 ---
function focusSearchInput() {
    // 点击搜索按钮时，自动聚焦到搜索输入框
    const searchInput = document.getElementById('searchInput');
    if (searchInput) {
        searchInput.focus();
        // 可选：滚动到搜索框位置（适配小屏幕）
        searchInput.scrollIntoView({ behavior: 'smooth', block: 'center' });
    }
}

// 检查登录状态并获取用户信息
async function checkLoginStatus() {
    try {
        const response = await fetch('/api/user/check-login', {
            credentials: 'include' // 确保携带cookie
        });
        const result = await response.json();

        if (result.loggedIn && result.user) {
            // 已登录：设置用户信息
            currentUser = result.user;
            window.CURRENT_USER_ID = currentUser.id;

            // 将用户信息存储到localStorage（可选）
            localStorage.setItem('currentUser', JSON.stringify(currentUser));
            localStorage.setItem('isLoggedIn', 'true');
            localStorage.setItem('currentUserId', currentUser.id.toString());

            // 更新页面显示用户信息
            updateUserDisplay();

            // 加载存储信息
            await refreshStorageInfo();

            console.log('用户已登录，ID:', currentUser.id);
        } else {
            // 未登录：跳转到登录页
            console.log('用户未登录，跳转到登录页');
            window.location.href = '/login';
        }
    } catch (error) {
        console.error('检查登录状态失败:', error);
        // 检查失败时也跳转到登录页
        window.location.href = '/login';
    }
}

// 更新用户显示信息
function updateUserDisplay() {
    // 在页面顶部显示当前用户信息
    const userInfo = document.querySelector('.user-info');
    const userName = document.getElementById('userName');
    if (currentUser && userInfo) {
        // 显示昵称或用户名，优先显示昵称
        const displayName = currentUser.nickname || currentUser.username || currentUser.email;
        userInfo.textContent = `欢迎，${displayName}`;
    }
    if (currentUser && userName) {
        // 显示用户名供点击退出
        const displayName = currentUser.nickname || currentUser.username || currentUser.email;
        userName.textContent = displayName;
        userName.style.display = 'block';
    }
}

// 获取当前用户ID（从session获取）
async function getCurrentUserId() {
    // 如果currentUser已设置，直接返回
    if (currentUser && currentUser.id) {
        return currentUser.id;
    }

    // 尝试从window.CURRENT_USER_ID获取（可能已被iframe设置）
    if (window.CURRENT_USER_ID) {
        return window.CURRENT_USER_ID;
    }

    // 从session获取
    try {
        const response = await fetch('/api/user/check-login', {
            credentials: 'include'
        });
        const result = await response.json();

        if (result.loggedIn && result.user) {
            currentUser = result.user;
            window.CURRENT_USER_ID = currentUser.id;
            return currentUser.id;
        }

        return null;
    } catch (error) {
        console.error('获取用户ID失败:', error);
        return null;
    }
}

// 拉取并显示用户存储信息
async function refreshStorageInfo() {
    try {
        const userId = await getCurrentUserId();
        if (!userId) {
            console.log('用户未登录，无法获取存储信息');
            return;
        }
        const resp = await fetch(`/api/user/${userId}/storage`);
        if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
        const json = await resp.json();
        if (!json.success) throw new Error(json.message || '获取存储信息失败');
        const used = json.data && typeof json.data.used === 'number' ? json.data.used : 0;
        const total = json.data && typeof json.data.total === 'number' ? json.data.total : 0;
        const el = document.getElementById('storageInfo');
        if (el) {
            el.textContent = `已使用 ${formatFileSize(used)} / ${formatFileSize(total)}`;
        }
    } catch (e) {
        console.error('加载存储信息失败:', e);
    }
}

// 设置所有全局事件监听器
function setupEventListeners() {
    // 点击模态框外部关闭
    document.getElementById('uploadModal').addEventListener('click', function(e) {
        if (e.target === this) {
            closeUploadModal();
        }
    });

    // 下拉框事件已移除，现在使用直接导航

    // 键盘事件 (全局)
    document.addEventListener('keydown', function(e) {
        if (e.key === 'Escape') {
            closeUploadModal();
        }
    });

    // 文件选择事件
    const fileInput = document.getElementById('fileInput');
    if (fileInput) {
        fileInput.addEventListener('change', function(e) {
            const files = e.target.files;
            if (files.length > 0) {
                handleFiles(files);
            }
        });
    }

    // 添加文件拖拽到页面的支持
    document.addEventListener('dragover', function(e) {
        e.preventDefault();
    });
    document.addEventListener('drop', function(e) {
        e.preventDefault();
        const files = e.dataTransfer.files;
        if (files.length > 0) {
            openUploadModal();
            // 将拖拽的文件设置到fileInput
            const fileInput = document.getElementById('fileInput');
            if (fileInput) {
                // 创建DataTransfer对象来设置文件
                const dataTransfer = new DataTransfer();
                for (let file of files) {
                    dataTransfer.items.add(file);
                }
                fileInput.files = dataTransfer.files;
                handleFiles(files);
            }
        }
    });
}

// 设置文件类型折叠功能
function setupFileTypesToggle() {
    const myFilesTrigger = document.getElementById('myFilesTrigger');
    const fileTypesContainer = document.getElementById('fileTypesContainer');
    const myFilesArrow = document.getElementById('myFilesArrow');

    if (myFilesTrigger && fileTypesContainer && myFilesArrow) {
        // 默认展开状态
        fileTypesContainer.classList.add('expanded');
        myFilesArrow.textContent = '▼';

        // 只对箭头部分添加点击事件，并扩大可点击判定范围
        myFilesArrow.addEventListener('click', function(e) {
            e.preventDefault();
            e.stopPropagation();
            const isExpanded = fileTypesContainer.classList.contains('expanded');
            if (isExpanded) {
                fileTypesContainer.classList.remove('expanded');
                myFilesArrow.textContent = '▶';
                myFilesArrow.classList.add('collapsed');
            } else {
                fileTypesContainer.classList.add('expanded');
                myFilesArrow.textContent = '▼';
                myFilesArrow.classList.remove('collapsed');
            }
        });

        // 点击“全部文件”右侧附近区域也可触发展开/收起，降低误触
        myFilesTrigger.addEventListener('click', function(e) {
            const rect = myFilesArrow.getBoundingClientRect();
            const padding = 10; // 扩展10px判定区域
            const withinArrowArea = e.clientX >= rect.left - padding && e.clientX <= rect.right + padding;
            if (withinArrowArea) {
                e.preventDefault();
                e.stopPropagation();
                myFilesArrow.click();
            }
        }, true);
    }
}

// 更新面包屑导航（已移到iframe内部）
function updateBreadcrumbNav(currentPath) {
    // 通知iframe更新面包屑
    const iframe = document.getElementById('contentIframe');
    if (iframe && iframe.contentWindow && iframe.contentWindow.updateBreadcrumbNav) {
        iframe.contentWindow.updateBreadcrumbNav(currentPath);
    }
}

// 设置搜索功能
function setupSearch() {
    // const searchInput = document.getElementById('searchInput');
    // searchInput.addEventListener('input', function(e) {
    //     clearTimeout(searchTimeout);
    //     setTimeout(() => {
    //         const query = e.target.value.toLowerCase();
    //         filteredFiles = mockFiles.filter(file =>
    //             file.name.toLowerCase().includes(query)
    //         );
    //         // renderFileList(); // 文件列表被注释
    //     }, 300);
    // });
}

// setupDropdown函数已移除

// 设置导航功能 (处理所有导航项的点击)
function setupNavigation() {
    // 选择所有导航项，包括文件类型项
    const navItems = document.querySelectorAll('.nav-item[data-section], .nav-item[data-type]');
    const contentIframe = document.getElementById('contentIframe');

    navItems.forEach(item => {
        item.addEventListener('click', function(e) {
            e.preventDefault();
            e.stopPropagation();

            const advancedSearch = document.getElementById('advancedSearch');
            if (advancedSearch) {
                advancedSearch.classList.remove('show');
            }

            const section = this.getAttribute('data-section');
            const fileType = this.getAttribute('data-type');

            const targetKey = section || fileType;
            if (!targetKey) return;

            // 移除所有活动状态
            document.querySelectorAll('.nav-item.active').forEach(el => el.classList.remove('active'));

            // 处理文件类型过滤
            if (fileType) {
                // 确保我的文件处于活动状态
                const homeItem = document.querySelector('.nav-item[data-section="home"]');
                if (homeItem) {
                    homeItem.classList.add('active');
                }

                // 调用iframe内的文件类型过滤函数
                if (contentIframe && contentIframe.contentWindow && contentIframe.contentWindow.filterByFileType) {
                    contentIframe.contentWindow.filterByFileType(fileType);
                }

                // 更新面包屑导航
                const typeNames = {
                    'image': '图片',
                    'document': '文档',
                    'video': '视频',
                    'audio': '音频',
                    'other': '其它',
                    'recent': '最近'
                };
                const breadcrumbText = typeNames[fileType] || '文件类型';
                updateBreadcrumbNav(breadcrumbText);
            } else if (section) {
                // 处理普通导航（首页、分享、回收站）
                this.classList.add('active');

                // 加载对应的iframe内容
                const targetPath = pathMappings[targetKey];
                if (targetPath) {
                    loadIframeContent(targetPath, targetKey);
                }
            }
        });
    });
}

// 设置键盘快捷键
function setupKeyboardShortcuts() {
    document.addEventListener('keydown', function(e) {
        // Ctrl/Cmd + U 打开上传
        if ((e.ctrlKey || e.metaKey) && e.key === 'u') {
            e.preventDefault();
            openUploadModal();
        }

        // Ctrl/Cmd + F 聚焦搜索框
        if ((e.ctrlKey || e.metaKey) && e.key === 'f') {
            e.preventDefault();
            document.getElementById('searchInput').focus();
        }
    });
}

// 加载iframe内容
function loadIframeContent(path, section) {

    // 获取搜索输入框元素
    const searchInput = document.getElementById('searchInput');
    // 将输入框的值清空，此时会显示 placeholder 文字
    searchInput.value = '';
    resetAdvancedSearch()
    const contentIframe = document.getElementById('contentIframe');
    contentIframe.style.opacity = '0.5';

    // 新增：根据传入的 section 更新当前页面标识
    if (section) {
        currentPageType = section; // section 对应 'home'/'shares'/'trash'
    }

    contentIframe.src = path;
    contentIframe.onload = () => {
        contentIframe.style.opacity = '1';

        // iframe加载完成后，通知iframe更新面包屑导航
        setTimeout(() => {
            if (contentIframe.contentWindow && contentIframe.contentWindow.updateBreadcrumbNav) {
                // 根据不同的section设置对应的面包屑文本
                let breadcrumbText = '全部文件';
                if (section === 'shares') {
                    breadcrumbText = '我的分享';
                } else if (section === 'trash') {
                    breadcrumbText = '回收站';
                }
                console.log('更新面包屑:', breadcrumbText); // 调试日志
                contentIframe.contentWindow.updateBreadcrumbNav(breadcrumbText);
            } else {
                console.log('iframe面包屑函数不可用'); // 调试日志
            }
        }, 200); // 增加延迟时间，确保iframe完全加载
    };
}

// --- 其他辅助函数 (保持不变) ---
function updateBreadcrumb(first, second) {
    // breadcrumb已被移除，此函数不再需要
    // const breadcrumb = document.querySelector('.breadcrumb');
    // breadcrumb.innerHTML = `<a href="#" class="breadcrumb-item">${first}</a><span class="breadcrumb-separator">/</span><span class="breadcrumb-item">${second}</span>`;
}
// 处理文件选择
function handleFiles(files) {
    if (files.length === 0) return;

    // 显示文件列表
    displayFileList(files);

    // 显示上传进度
    const uploadProgress = document.getElementById('uploadProgress');
    const uploadBtn = document.getElementById('uploadBtn');

    if (uploadProgress) {
        uploadProgress.style.display = 'block';
    }

    if (uploadBtn) {
        uploadBtn.innerHTML = '<span class="loading"></span> 准备中...';
        uploadBtn.disabled = true;
    }

    // 显示选择的文件信息
    console.log(`选择了 ${files.length} 个文件:`);
    for (let i = 0; i < files.length; i++) {
        const file = files[i];
        console.log(`- ${file.name} (${formatFileSize(file.size)})`);
    }

    // 模拟文件处理
    setTimeout(() => {
        if (uploadBtn) {
            uploadBtn.innerHTML = '开始上传';
            uploadBtn.disabled = false;
        }
    }, 1000);
}

// 显示文件列表
function displayFileList(files) {
    const fileListContainer = document.getElementById('fileListContainer');
    const fileList = document.getElementById('fileList');

    if (!fileListContainer || !fileList) return;

    // 清空现有列表
    fileList.innerHTML = '';

    // 添加文件项
    for (let i = 0; i < files.length; i++) {
        const file = files[i];
        const fileItem = createFileItem(file, i);
        fileList.appendChild(fileItem);
    }

    // 显示文件列表容器
    fileListContainer.style.display = 'block';
}

// 创建文件项
function createFileItem(file, index) {
    const fileItem = document.createElement('div');
    fileItem.className = 'file-item';
    fileItem.dataset.index = index;

    const fileIcon = getFileIcon(file.name);
    const fileSize = formatFileSize(file.size);

    fileItem.innerHTML = `
        <div class="file-icon">${fileIcon}</div>
        <div class="file-info">
            <div class="file-name" title="${file.name}">${file.name}</div>
            <div class="file-size">${fileSize}</div>
        </div>
    `;

    return fileItem;
}

// 获取文件图标
function getFileIcon(fileName) {
    const extension = fileName.split('.').pop().toLowerCase();
    const iconMap = {
        'pdf': '📄',
        'doc': '📄', 'docx': '📄',
        'xls': '📊', 'xlsx': '📊',
        'ppt': '📊', 'pptx': '📊',
        'txt': '📝',
        'jpg': '🖼️', 'jpeg': '🖼️', 'png': '🖼️', 'gif': '🖼️', 'bmp': '🖼️',
        'mp4': '🎥', 'avi': '🎥', 'mov': '🎥', 'wmv': '🎥',
        'mp3': '🎵', 'wav': '🎵', 'flac': '🎵',
        'zip': '📦', 'rar': '📦', '7z': '📦',
        'html': '🌐', 'htm': '🌐', 'css': '🎨', 'js': '⚡',
        'exe': '⚙️', 'msi': '⚙️',
        'iso': '💿', 'dmg': '💿'
    };
    return iconMap[extension] || '📄';
}

// 移除文件
function removeFile(index) {
    const fileInput = document.getElementById('fileInput');
    if (!fileInput) return;

    const files = Array.from(fileInput.files);
    files.splice(index, 1);

    // 更新文件输入
    const dataTransfer = new DataTransfer();
    files.forEach(file => dataTransfer.items.add(file));
    fileInput.files = dataTransfer.files;

    // 重新显示文件列表
    if (files.length > 0) {
        displayFileList(files);
    } else {
        clearFileList();
    }
}

// 清空文件列表
function clearFileList() {
    const fileListContainer = document.getElementById('fileListContainer');
    const fileInput = document.getElementById('fileInput');

    if (fileListContainer) {
        fileListContainer.style.display = 'none';
    }

    if (fileInput) {
        fileInput.value = '';
    }
}
// 打开上传模态框
function openUploadModal() {
    const modal = document.getElementById('uploadModal');
    modal.classList.add('show');
    document.body.style.overflow = 'hidden';
}
// 关闭上传模态框
function closeUploadModal() {
    const modal = document.getElementById('uploadModal');
    modal.classList.remove('show');
    document.body.style.overflow = 'auto';

    // 重置状态
    document.getElementById('uploadProgress').style.display = 'none';
    document.getElementById('progressFill').style.width = '0%';
    document.getElementById('progressText').textContent = '准备上传...';
    document.getElementById('uploadBtn').innerHTML = '开始上传';
    document.getElementById('uploadBtn').disabled = false;

    // 清空文件列表和输入
    clearFileList();
}
// 开始上传
async function startUpload() {
    const fileInput = document.getElementById('fileInput');
    const files = fileInput.files;

    if (files.length === 0) {
        showError('请先选择文件');
        return;
    }

    const uploadBtn = document.getElementById('uploadBtn');
    uploadBtn.innerHTML = '<span class="loading"></span> 上传中...';
    uploadBtn.disabled = true;

    try {
        // 上传每个文件
        for (let i = 0; i < files.length; i++) {
            const file = files[i];
            await uploadFile(file, i + 1, files.length);
        }

        showSuccess('所有文件上传成功！');
        closeUploadModal();
        // 刷新文件列表 - 通知iframe中的文件列表页面刷新
        const iframe = document.getElementById('contentIframe');
        if (iframe && iframe.contentWindow && iframe.contentWindow.loadFileList) {
            iframe.contentWindow.loadFileList();
        }

    } catch (error) {
        console.error('上传失败:', error);
        showError('上传失败: ' + error.message);
    } finally {
        uploadBtn.innerHTML = '开始上传';
        uploadBtn.disabled = false;
    }
}

// 上传单个文件
async function uploadFile(file, currentIndex, totalFiles) {
    const chunkSize = 2 * 1024 * 1024; // 2MB
    const totalChunks = Math.ceil(file.size / chunkSize);
    const fileIdentifier = generateFileIdentifier(file);

    console.log(`开始上传文件: ${file.name}`);
    console.log(`文件大小: ${file.size} bytes`);
    console.log(`分片数量: ${totalChunks}`);

    // 1. 检查文件是否已存在
    const checkResult = await checkFileExists(file.name, file.size, fileIdentifier);
    if (checkResult.exists) {
        console.log('文件已存在，跳过上传');
        return;
    }

    // 2. 分片上传
    for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
        const start = chunkIndex * chunkSize;
        const end = Math.min(start + chunkSize, file.size);
        const chunk = file.slice(start, end);

        await uploadChunk(file, chunk, chunkIndex, totalChunks, fileIdentifier);

        // 更新进度
        const progress = ((currentIndex - 1) * 100 + ((chunkIndex + 1) / totalChunks) * 100) / totalFiles;
        document.getElementById('progressFill').style.width = progress + '%';
        document.getElementById('progressText').textContent =
            `上传中... ${currentIndex}/${totalFiles} - ${Math.round(progress)}%`;
    }

    // 3. 合并文件（即使是单个分片也需要合并）
    await mergeFile(file.name, file.size, fileIdentifier, totalChunks);

    console.log(`文件 ${file.name} 上传完成`);
}

// 生成文件标识符（简化版本，确保不超过32字符）
function generateFileIdentifier(file) {
    // 使用文件名、大小和修改时间的哈希值
    const str = file.name + '_' + file.size + '_' + file.lastModified;
    return simpleHash(str).substring(0, 32);
}

// 简单的哈希函数
function simpleHash(str) {
    let hash = 0;
    if (str.length === 0) return hash.toString();
    for (let i = 0; i < str.length; i++) {
        const char = str.charCodeAt(i);
        hash = ((hash << 5) - hash) + char;
        hash = hash & hash; // 转换为32位整数
    }
    return Math.abs(hash).toString(16).padStart(8, '0') +
        Math.abs(hash * 31).toString(16).padStart(8, '0') +
        Math.abs(hash * 37).toString(16).padStart(8, '0') +
        Math.abs(hash * 41).toString(16).padStart(8, '0');
}

// 检查文件是否存在
async function checkFileExists(fileName, fileSize, fileMD5) {
    try {
        const userId = await getCurrentUserId();
        if (!userId) {
            alert('用户未登录，请先登录');
            window.location.href = '/login';
            return;
        }

        const params = new URLSearchParams();
        params.append('fileName', fileName);
        params.append('fileSize', fileSize.toString());
        params.append('fileMD5', fileMD5);
        params.append('userId', userId); // 添加用户ID

        const response = await fetch('/api/filebase/check', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded'
            },
            body: params
        });

        if (!response.ok) {
            throw new Error(`HTTP错误: ${response.status}`);
        }

        const result = await response.json();
        return result;
    } catch (error) {
        console.error('检查文件失败:', error);
        return { exists: false };
    }
}

// 上传分片
async function uploadChunk(file, chunk, chunkIndex, totalChunks, fileIdentifier) {
    const userId = await getCurrentUserId();
    if (!userId) {
        throw new Error('用户未登录，无法上传文件');
    }

    const formData = new FormData();
    formData.append('file', chunk);
    formData.append('fileName', file.name);
    formData.append('fileSize', file.size.toString());
    formData.append('chunkIndex', chunkIndex.toString());
    formData.append('totalChunks', totalChunks.toString());
    formData.append('fileMD5', fileIdentifier);
    formData.append('userId', userId); // 添加用户ID

    const response = await fetch('/api/filebase/upload-chunk', {
        method: 'POST',
        body: formData
    });

    if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`分片上传失败: ${response.status} - ${errorText}`);
    }

    const result = await response.json();
    if (!result.success) {
        throw new Error(result.message || '分片上传失败');
    }
}

// 合并文件
async function mergeFile(fileName, fileSize, fileMD5, totalChunks) {
    const userId = await getCurrentUserId();
    if (!userId) {
        alert('用户未登录，请先登录');
        window.location.href = '/login';
        return;
    }

    const params = new URLSearchParams();
    params.append('fileName', fileName);
    params.append('fileSize', fileSize.toString());
    params.append('fileMD5', fileMD5);
    params.append('totalChunks', totalChunks.toString());
    params.append('userId', userId); // 添加用户ID

    // 获取当前目录的parentId
    const iframe = document.getElementById('contentIframe');
    let currentParentId = 0; // 默认为根目录
    if (iframe && iframe.contentWindow && typeof iframe.contentWindow.currentParentId !== 'undefined') {
        currentParentId = iframe.contentWindow.currentParentId;
    }
    params.append('parentId', currentParentId.toString()); // 添加父目录ID

    const response = await fetch('/api/filebase/merge', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: params
    });

    if (!response.ok) {
        const errorText = await response.text();
        throw new Error(`文件合并失败: ${response.status} - ${errorText}`);
    }

    const result = await response.json();
    if (!result.success) {
        throw new Error(result.message || '文件合并失败');
    }
}

// 格式化文件大小
// function formatFileSize(bytes) {
//     if (!bytes || bytes === 0) return '0 B';
//
//     const units = ['B', 'KB', 'MB', 'GB', 'TB'];
//     let size = bytes;
//     let unitIndex = 0;
//
//     while (size >= 1024 && unitIndex < units.length - 1) {
//         size /= 1024;
//         unitIndex++;
//     }
//
//     return size.toFixed(1) + ' ' + units[unitIndex];
// }
function formatFileSize(size) {
    console.log('🔍 formatFileSize 接收的参数类型：', typeof size, '值：', size);

    // 情况1：参数是字符串且已包含单位（如"13.5KB"），直接返回
    if (typeof size === 'string' && /^[0-9.]+(\s*[BKMG]B|B)$/i.test(size)) {
        return size;
    }

    // 情况2：参数是数字（原始字节数），计算并格式化
    if (typeof size === 'number' && !isNaN(size) && size >= 0) {
        const units = ['B', 'KB', 'MB', 'GB'];
        let unitIndex = 0;
        let formattedSize = size;
        while (formattedSize >= 1024 && unitIndex < units.length - 1) {
            formattedSize /= 1024;
            unitIndex++;
        }
        return formattedSize.toFixed(1) + ' ' + units[unitIndex];
    }

    // 情况3：参数无效，返回默认值
    return '-';
}

// 显示成功消息
function showSuccess(message) {
    const successMsg = document.getElementById('successMessage');
    const errorMsg = document.getElementById('errorMessage');

    // 先隐藏错误消息
    if (errorMsg) {
        errorMsg.classList.remove('show');
    }

    if (successMsg) {
        const messageDiv = successMsg.querySelector('div');
        if (messageDiv) {
            messageDiv.textContent = message;
        }
        successMsg.classList.add('show');
        setTimeout(() => {
            successMsg.classList.remove('show');
        }, 3000);
    }
}

// 显示错误消息
function showError(message) {
    const successMsg = document.getElementById('successMessage');
    const errorMsg = document.getElementById('errorMessage');

    // 先隐藏成功消息
    if (successMsg) {
        successMsg.classList.remove('show');
    }

    if (errorMsg) {
        const messageDiv = errorMsg.querySelector('div');
        if (messageDiv) {
            messageDiv.textContent = message;
        }
        errorMsg.classList.add('show');
        setTimeout(() => {
            errorMsg.classList.remove('show');
        }, 3000);
    }
}

// 渲染文件列表
function renderFileList() {
    const tbody = document.getElementById('fileTableBody');
    tbody.innerHTML = '';

    filteredFiles.forEach((file, index) => {
        const row = document.createElement('tr');
        row.innerHTML = `
                    <td>
                        <input type="checkbox" class="file-checkbox" data-index="${index}">
                    </td>
                    <td>
                        <div class="file-item">
                            <div class="file-icon ${file.type}">${file.icon}</div>
                            <div class="file-name">${file.name}</div>
                        </div>
                    </td>
                    <td><div class="file-size">${file.size}</div></td>
                    <td><div class="file-type">${file.type}</div></td>
                    <td><div class="file-date">${file.date}</div></td>
                `;
        tbody.appendChild(row);
    });
}
// 按文件类型过滤
function filterFilesByType(type) {
    if (type === 'recent') {
        // 显示最近的文件（按日期排序）
        filteredFiles = [...mockFiles].sort((a, b) => new Date(b.date) - new Date(a.date));
    } else {
        // 按类型过滤
        filteredFiles = mockFiles.filter(file => file.type === type);
    }
    renderFileList();
}

// 显示首页
function showHomeSection() {
    filteredFiles = [...mockFiles];
    renderFileList();
    // updateBreadcrumb('首页', '我的文件'); // breadcrumb已被移除
}

// 显示分享页面
function showSharesSection() {
    // 模拟分享文件
    filteredFiles = mockFiles.filter(file => file.name.includes('分享') || Math.random() > 0.7);
    renderFileList();
    // updateBreadcrumb('首页', '我的分享'); // breadcrumb已被移除
}

// 显示回收站
function showTrashSection() {
    // 模拟回收站文件
    filteredFiles = mockFiles.filter(file => file.name.includes('删除') || Math.random() > 0.8);
    renderFileList();
    // updateBreadcrumb('首页', '回收站'); // breadcrumb已被移除
}

// --- 搜索功能 ---
// 新增：监听来自 iframe 的消息，关闭提示面板
window.addEventListener('message', function(event) {
    // 验证消息来源（可选，增强安全性）
    // if (event.origin !== '你的网站域名') return;

    // 如果收到关闭指令，执行关闭
    if (event.data === 'closeSuggestPanel') {
        hideSuggestPanel();
    }
});

// 获取高级搜索参数（从弹窗提取，带默认值）
function setupSearchLogic(){
    // 1. 接口请求工具函数（requestApi）
    async function requestApi(url, method = 'GET', data = {}) {
        const userId = await getCurrentUserId();
        if (!userId) {
            console.error('用户ID为空，无法请求接口');
            return null;
        }
        try {
            // 统一将 userId 放入 data 内部（与后端实体对齐）
            const requestData = { ...data, userId };
            const headers = {
                'Content-Type': method === 'POST' ? 'application/json' : 'text/plain'
            };
            const response = await fetch(url, {
                method,
                headers,
                body: method === 'POST' ? JSON.stringify(requestData) : null
            });
            return await response.json();
        } catch (error) {
            console.error(`请求${url}失败:`, error);
            return null;
        }
    }

    // 2. 隐藏提示面板工具函数
    function hideSuggestPanel() {
        const suggestPanel = document.getElementById('searchSuggest');
        suggestPanel.style.display = 'none';
    }

    // --- 第二步：放历史记录相关函数（依赖 requestApi）---
    // 1. 从数据库获取搜索历史
    async function getSearchHistoryFromDb() {
        // 传递当前页面标识 currentPage
        const userId = await getCurrentUserId();
        if (!userId) return [];

        const result = await requestApi('/api/history/get', 'POST', {
            userId: userId,
            currentPage: currentPageType
        });
        return (result || []).filter(item => item.keyword).slice(0, 10);
    }

    // 2. 单条删除搜索历史
    async function deleteSearchHistoryFromDb(historyId) {
        const userId = await getCurrentUserId();
        if (!userId) {
            alert('用户未登录，无法删除历史记录');
            return false;
        }
        console.log("开始删除"+userId+historyId)
        const result = await requestApi('/api/history/clear', 'POST', {userId: userId,  id: historyId });
        if (result && result.code === 200) {
            renderSearchHistory(); // 重新渲染历史记录列表
            return true;
        }
        alert('删除历史记录失败，请重试');
        return false;
    }

    // 3. 同步搜索历史到数据库
    async function syncSearchHistoryToDb(fileHistory) {
        if (!fileHistory.keyword) return;
        const historyData = {
            keyword: fileHistory.keyword,
            fileType: fileHistory.fileType,
            startTime: fileHistory.startTime,
            endTime: fileHistory.endTime,
            minSize: fileHistory.minSize,
            maxSize: fileHistory.maxSize,
            sortField: fileHistory.sortField,
            sortOrder: fileHistory.sortOrder,
            currentPage: currentPageType
        };
        await requestApi('/api/history/record', 'POST', historyData);
    }

    // 4. 渲染搜索历史
    async function renderSearchHistory() {
        const suggestPanel = document.getElementById('searchSuggest');
        const historyList = await getSearchHistoryFromDb();
        if (historyList.length === 0) {
            suggestPanel.innerHTML = '<div class="search-empty">暂无搜索历史</div>';
            return;
        }
        let html = `<div class="search-history-header"><span>搜索历史</span></div>`;
        historyList.forEach(history => {
            html += `
                <div class="search-history-item" onclick="selectHistoryKeyword('${history.keyword}')">
                    <span>${history.keyword}</span>
                    <span class="search-history-delete" onclick="event.stopPropagation(); deleteSearchHistoryFromDb(${history.id})">删除</span>
                </div>
            `;
        });
        suggestPanel.innerHTML = html;
    }

    // 5. 选择历史关键词
    function selectHistoryKeyword(keyword) {
        const searchInput = document.getElementById('searchInput');
        searchInput.value = keyword;
        hideSuggestPanel();
        //调用高级搜索
        performSearch();


    }

    // --- 第三步：放实时匹配相关函数（依赖 requestApi）---
    let debounceTimer = null;
    async function fetchMatchContent() {
        const searchInput = document.getElementById('searchInput');
        const keyword = searchInput.value.trim();
        if (!keyword) return;

        // 1. 获取完整高级搜索参数（与/advanced完全一致）
        const fileHistory = getAdvancedSearchParams();
        fileHistory.keyword = keyword;

        clearTimeout(debounceTimer);
        debounceTimer = setTimeout(async () => {
            const suggestPanel = document.getElementById('searchSuggest');
            suggestPanel.innerHTML = '<div class="search-empty">正在匹配...</div>';

            // 核心修改：根据当前页面标识，选择对应的实时匹配接口
            let matchApiUrl
            if(currentPageType === 'trash'){
                matchApiUrl ='/api/search/matchRecycled'
            }
            else if(currentPageType === 'shares'){
                matchApiUrl ='/api/search/matchShare'
            }
            else{
                matchApiUrl ='/api/search/match'
            }

            // 调用后端实时匹配接口（使用动态地址）
            const result = await requestApi(matchApiUrl, 'POST', fileHistory);
            console.log('实时匹配接口返回:', result);

            // 【关键修改】与/advanced对齐的成功判断：code === 200 且 data 存在
            if (!result || result.code !== 200 || !result.data) {
                suggestPanel.innerHTML = '<div class="search-empty">暂无匹配内容</div>';
                return;
            }

            // 3. 渲染匹配结果
            const matchList = result.data;
            if (matchList.length === 0) {
                suggestPanel.innerHTML = '<div class="search-empty">暂无匹配内容</div>';
                return;
            }

            let html = '';
            matchList.forEach(item => {
                // 核心修改：根据当前页面类型显示不同内容
                if (currentPageType === 'trash') {
                    // 回收站：显示删除时间
                    html += `
            <div class="search-match-item" onclick="triggerSearchFromMatch()">
                <div class="search-match-name">${item.fileName}</div>
                <div class="search-match-deleteTime">删除时间：${formatDate(item.deleteTime)}</div>
            </div>
        `;
                } else if(currentPageType === 'shares'){
                    // 回收站：显示时间
                    html += `
            <div class="search-match-item" onclick="triggerSearchFromMatch()">
                <div class="search-match-name">${item.fileName}</div>
                <div class="search-match-createTime">分享时间：${formatDate(item.createTime)}</div>
            </div>
        `;
                }
                else {
                    // 其他页面：显示文件内容
                    html += `
            <div class="search-match-item" onclick="triggerSearchFromMatch()">
                <div class="search-match-name">${item.fileName}</div>
                <div class="search-match-content">${item.fileContent}</div>
            </div>
        `;
                }
            });
            suggestPanel.innerHTML = html;
        }, 300);
    }

    // 新增：日期格式化工具函数（放在setupSearchLogic函数外部）
    function formatDate(dateString) {
        if (!dateString) return '-';
        try {
            const date = new Date(dateString);
            return date.toLocaleDateString('zh-CN') + ' ' + date.toLocaleTimeString('zh-CN', {hour: '2-digit', minute: '2-digit'});
        } catch (error) { return dateString; }
    }

    // 触发匹配结果搜索
    function triggerSearchFromMatch() {
        performSearch();
        hideSuggestPanel();
    }

    // --- 第四步：放输入框事件初始化函数（依赖上面所有函数）---
    function initSearchInputEvents() {
        const searchInput = document.getElementById('searchInput');
        const suggestPanel = document.getElementById('searchSuggest');

        // 输入框聚焦
        searchInput.addEventListener('focus', async () => {
            const keyword = searchInput.value.trim();
            if (keyword === '') {
                await renderSearchHistory();
            } else {
                fetchMatchContent();
            }
            suggestPanel.style.display = 'block';
        });

        // 输入框内容变化
        searchInput.addEventListener('input', () => {
            const keyword = searchInput.value.trim();
            if (keyword === '') {
                renderSearchHistory();
            } else {
                fetchMatchContent();
            }
        });

        // 点击外部隐藏
        document.addEventListener('click', (e) => {
            // 判断点击区域是否在搜索框内（包括输入框、搜索按钮等）
            const isInSearchBox = e.target.closest('.search-box') !== null;
            // 判断点击区域是否在提示面板内
            const isInSuggestPanel = e.target.closest('.search-suggest') !== null;

            // 只有当点击区域既不在搜索框也不在提示面板时，才关闭面板
            if (!isInSearchBox && !isInSuggestPanel) {
                hideSuggestPanel();
            }
        });

        // 回车搜索
        searchInput.addEventListener('keypress', (e) => {
            if (e.key === 'Enter') {
                hideSuggestPanel();
                performSearch();
            }
        });
    }


    // 核心新增：空值处理工具函数（将空字符串/undefined转为null）
    function formatNullValue(value) {
        // 空字符串、undefined、纯空格都转为null
        if (value === undefined || value === '' || (typeof value === 'string' && value.trim() === '')) {
            return null;
        }
        return value;
    }

    function getAdvancedSearchParams() {
        // 1. 获取当前窗口所有搜索元素
        const searchInput = document.getElementById('searchInput');
        const timeRange = document.getElementById('timeRange');
        const startDate = document.getElementById('startDate');
        const endDate = document.getElementById('endDate');
        const fileSizeRange = document.getElementById('fileSizeRange');
        const minSize = document.getElementById('minSize');
        const maxSize = document.getElementById('maxSize');
        const fileTypeFilter = document.getElementById('fileTypeFilter');
        const sortBy = document.getElementById('sortBy');
        const sortOrder = document.getElementById('sortOrder');
        // 若有其他字段（如fileName、realName、isDirectory），按实际DOM ID获取
        const fileNameInput = document.getElementById('fileName') || { value: '' }; // 示例：文件名筛选（按实际是否有此DOM调整）
        const realNameInput = document.getElementById('realName') || { value: '' }; // 示例：真实名筛选
        const isDirectorySelect = document.getElementById('isDirectory') || { value: '' }; // 示例：是否目录筛选

        // 2. 时间参数处理（空值转null）
        let startTime = null;
        let endTime = null;
        const today = new Date();
        if (timeRange.value === 'today') {
            startTime = new Date(today.setHours(0, 0, 0, 0));
            endTime = new Date(today.setHours(23, 59, 59, 999));
        } else if (timeRange.value === 'week') {
            startTime = new Date(today.getTime() - 7 * 24 * 60 * 60 * 1000);
            endTime = new Date(today.setHours(23, 59, 59, 999));
        } else if (timeRange.value === 'month') {
            startTime = new Date(today.getFullYear(), today.getMonth(), 1, 0, 0, 0, 0);
            endTime = new Date(today.getFullYear(), today.getMonth() + 1, 0, 23, 59, 59, 999);
        } else if (timeRange.value === 'year') {
            startTime = new Date(today.getFullYear(), 0, 1, 0, 0, 0, 0);
            endTime = new Date(today.getFullYear(), 11, 31, 23, 59, 59, 999);
        } else if (timeRange.value === 'custom' && startDate.value && endDate.value) {
            startTime = new Date(startDate.value);
            endTime = new Date(endDate.value);
        }
        // 时间空值处理：未选择时间范围则保持null

        // 3. 大小参数处理（空值转null）
        let minSizeBytes = null;
        let maxSizeBytes = null;
        if (fileSizeRange.value === '0-1MB') {
            maxSizeBytes = 1 * 1024 * 1024;
        } else if (fileSizeRange.value === '1-10MB') {
            minSizeBytes = 1 * 1024 * 1024;
            maxSizeBytes = 10 * 1024 * 1024;
        } else if (fileSizeRange.value === '10-100MB') {
            minSizeBytes = 10 * 1024 * 1024;
            maxSizeBytes = 100 * 1024 * 1024;
        } else if (fileSizeRange.value === '100MB+') {
            minSizeBytes = 100 * 1024 * 1024;
        } else if (fileSizeRange.value === 'custom' && minSize.value && maxSize.value) {
            minSizeBytes = formatNullValue(Number(minSize.value)) ? Number(minSize.value) * 1024 * 1024 : null;
            maxSizeBytes = formatNullValue(Number(maxSize.value)) ? Number(maxSize.value) * 1024 * 1024 : null;
        }
        // 大小空值处理：未选择大小范围则保持null

        // 4. 排序参数处理（空值转null）
        const sortFieldMap = {
            'name': 'fileName',
            'size': 'fileSize',
            'time': 'userFileUpdateTime',
            'type': 'fileType'
        };
        // 先获取映射值
        let mappedSortField = sortFieldMap[sortBy.value];
        // 如果映射值是userFileUpdateTime，强制设为null；否则正常处理空值
        const finalSortField = mappedSortField === 'userFileUpdateTime'
            ? null
            : formatNullValue(mappedSortField) || null;  // 这里默认也改为null，避免传入无效字段

        const finalSortOrder =
            ['ASC', 'DESC'].includes(sortOrder.value.toUpperCase())
                ? sortOrder.value.toUpperCase()
                : 'DESC'; // 默认为降序

        // 5. 构建FileHistory入参（所有字段空值统一为null）
        // 注意：getAdvancedSearchParams是同步函数，但需要在异步函数中调用
        // 因此需要在调用getAdvancedSearchParams之前先获取userId
        const fileHistory = {
            // 基础字段（用户ID必传，非空）
            userId: null, // 将在performSearch中异步设置
            // 关键词相关（空值转null）
            keyword: formatNullValue(searchInput.value.trim()),
            fileName: formatNullValue(fileNameInput.value.trim()), // 按实际是否有此筛选字段调整
            realName: formatNullValue(realNameInput.value.trim()), // 按实际是否有此筛选字段调整
            // 类型/目录筛选（空值转null）
            fileType: formatNullValue(fileTypeFilter.value),
            isDirectory: formatNullValue(isDirectorySelect.value) ? Number(isDirectorySelect.value) : null, // 转数字（与后端实体对齐）
            // 大小范围（已处理空值）
            minSize: minSizeBytes,
            maxSize: maxSizeBytes,
            // 时间范围（已处理空值，转时间戳与后端兼容）
            startTime: startTime ? startTime.getTime() : null,
            endTime: endTime ? endTime.getTime() : null,
            // 排序参数（已处理空值）
            sortField: finalSortField,
            sortOrder: finalSortOrder,
            // 搜索时间（前端无需传，后端自动填充）
            searchTime: null
        };

        return fileHistory;
    }


    // 执行搜索
    async function performSearch() {
        console.log('开始执行搜索（已处理空值）');
        console.log(currentPageType)

        // 1. 确认iframe存在并加载完成
        const contentIframe = document.getElementById('contentIframe');
        if (!contentIframe) {
            console.error('未找到 contentIframe 元素');
            return;
        }
        await new Promise((resolve) => {
            if (contentIframe.contentWindow.document.readyState === 'complete') {
                resolve();
                return;
            }
            contentIframe.onload = resolve;
        });

        // 2. 获取iframe内部DOM
        const iframeDoc = contentIframe.contentDocument || contentIframe.contentWindow.document;
        let tbody;
        // 根据当前页面类型获取对应的tbody ID
        if (currentPageType === 'trash') {
            tbody = iframeDoc.getElementById('trashTableBody');
        }
        else if(currentPageType === 'shares'){
            tbody = iframeDoc.getElementById('shareTableBody');
        }
        else {
            tbody = iframeDoc.getElementById('fileTableBody');
        }
        if (!tbody) {
            if(currentPageType ==='shares'){
                console.error(`shares.html中未找到对应的tbody元素`);
            }
            else
                console.error(`${currentPageType === 'trash' ? 'trash.html' : 'home.html'} 中未找到对应的tbody元素`);
            return;
        }

        // 3. 获取当前用户ID
        const userId = await getCurrentUserId();
        if (!userId) {
            alert('用户未登录，请先登录');
            window.location.href = '/login';
            return;
        }

        // 4. 获取处理完空值的FileHistory（核心：入参就是FileHistory）
        const fileHistory = getAdvancedSearchParams();
        fileHistory.userId = userId; // 设置用户ID
        console.log('处理空值后的FileHistory入参:', fileHistory);

        //添加到搜索历史
        syncSearchHistoryToDb(fileHistory);

        // 4. 显示加载状态
        // 4. 显示加载状态（新增shares页面处理，与表格6列对齐）
        if (currentPageType === 'trash') {
            tbody.innerHTML = '<tr><td colspan="6" class="loading"><div>正在搜索...</div></td></tr>';
        } else if (currentPageType === 'shares') { // 新增shares页面加载状态
            tbody.innerHTML = '<tr><td colspan="6" class="loading"><div>正在搜索...</div></td></tr>';
        } else {
            tbody.innerHTML = '<tr><td colspan="5" class="loading"><div>正在搜索...</div></td></tr>';
        }

        try {
            // 核心修改：根据当前页面标识，选择对应的高级搜索接口
            let searchApiUrl
            if(currentPageType=== 'trash'){
                searchApiUrl='/api/search/advancedRecycled'
            }
            else if(currentPageType=== 'shares'){
                searchApiUrl='/api/search/advancedShare'
            }
            else {
                searchApiUrl='/api/search/advanced'
            }

            // 调用后端接口（使用动态地址）
            const response = await fetch(searchApiUrl, {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify(fileHistory) // 直接传处理好空值的FileHistory
            });

            if (!response.ok) throw new Error(`状态码：${response.status}`);
            const searchResult = await response.json();
            console.log('后端返回搜索结果:', searchResult);

            // 6. 渲染结果
            const iframeWindow = contentIframe.contentWindow;
            if (currentPageType === 'trash') {
                // 回收站页面：使用回收站专用渲染格式
                if (iframeWindow && typeof iframeWindow.renderTrashList === 'function') {
                    // 适配trash.html需要的分页结构
                    iframeWindow.renderTrashList({
                        list: searchResult || [],
                        pageNum: 1,
                        pages: searchResult && searchResult.length > 0 ? 1 : 0,
                        total: searchResult ? searchResult.length : 0
                    });
                } else {
                    console.error('trash.html 未暴露 renderTrashList 函数');
                }
            }
            else if(currentPageType === 'shares'){
                // 分享页面：使用分享专用渲染格式
                if (iframeWindow && typeof iframeWindow.renderShareList === 'function') {
                    // 适配shares.html需要的分页结构
                    iframeWindow.renderShareList({
                        list: searchResult || [],
                        pageNum: 1,
                        pages: searchResult && searchResult.length > 0 ? 1 : 0,
                        total: searchResult ? searchResult.length : 0
                    });
                } else {
                    console.error('shares.html 未暴露 renderShareList 函数');
                }
            }
            else {
                // 其他页面：使用原有渲染逻辑
                if (iframeWindow && typeof iframeWindow.renderFileList === 'function') {
                    iframeWindow.renderFileList({
                        list: searchResult || [],
                        pageNum: 1,
                        pages: searchResult && searchResult.length > 0 ? 1 : 0
                    });
                } else {
                    console.error('home.html 未暴露 renderFileList 函数');
                }
            }

            // 7. 更新面包屑（原有逻辑不变）
            if (iframeWindow && typeof iframeWindow.updateBreadcrumbNav === 'function') {
                const breadcrumbText = fileHistory.keyword
                    ? `搜索结果: "${fileHistory.keyword}"`
                    : '高级搜索结果';
                iframeWindow.updateBreadcrumbNav(breadcrumbText);
            }

            // 8. 关闭高级搜索弹窗（原有逻辑不变）
            const advancedModal = document.getElementById('advancedSearchModal');
            if (advancedModal && advancedModal.style.display === 'flex') {
                toggleAdvancedSearch();
            }

        } catch (error) {
            console.error('搜索失败:', error);
            if (currentPageType === 'trash') {
                tbody.innerHTML = '<tr><td colspan="6" class="empty-state"><div class="empty-icon">❌</div><div>搜索失败，请稍后重试</div></td></tr>';
            } else if (currentPageType === 'shares') {  // 新增shares页面的错误状态
                tbody.innerHTML = '<tr><td colspan="6" class="empty-state"><div class="empty-icon">❌</div><div>搜索失败，请稍后重试</div></td></tr>';
            } else {
                tbody.innerHTML = '<tr><td colspan="5" class="empty-state"><div class="empty-icon">❌</div><div>搜索失败，请稍后重试</div></td></tr>';
            }
        }
    }

    // 切换高级搜索弹窗
    function toggleAdvancedSearch() {
        const modal = document.getElementById('advancedSearchModal');
        if (modal.style.display === 'none') {
            modal.style.display = 'flex';
            // 防止背景滚动
            document.body.style.overflow = 'hidden';
        } else {
            modal.style.display = 'none';
            // 恢复背景滚动
            document.body.style.overflow = 'auto';
        }
    }

    // 应用高级搜索
    function applyAdvancedSearch() {
        // 直接调用统一搜索入口，自动处理弹窗参数
        performSearch();
        // 2. 关闭高级搜索弹窗（调用已有的弹窗切换函数）
        toggleAdvancedSearch();
    }

    // 设置高级搜索面板的事件监听器
    function setupAdvancedSearchListeners() {
        const timeRange = document.getElementById('timeRange');
        const fileSizeRange = document.getElementById('fileSizeRange');
        const customTime = document.getElementById('customTime');
        const customSize = document.getElementById('customSize');

        timeRange.addEventListener('change', function() {
            customTime.style.display = this.value === 'custom' ? 'flex' : 'none';
        });

        fileSizeRange.addEventListener('change', function() {
            customSize.style.display = this.value === 'custom' ? 'flex' : 'none';
        });

        // document.getElementById('searchInput').addEventListener('keypress', function(e) {
        //     if (e.key === 'Enter') {
        //         performSearch();
        //     }
        // });

        customTime.style.display = timeRange.value === 'custom' ? 'flex' : 'none';
        customSize.style.display = fileSizeRange.value === 'custom' ? 'flex' : 'none';
    }

    // 初始化高级搜索监听器
    setupAdvancedSearchListeners();

    // 添加ESC键关闭弹窗功能
    document.addEventListener('keydown', function(e) {
        if (e.key === 'Escape') {
            const modal = document.getElementById('advancedSearchModal');
            if (modal && modal.style.display === 'flex') {
                toggleAdvancedSearch();
            }
        }
    });

    //在 setupSearchLogic 函数末尾调用输入框事件初始化
    initSearchInputEvents();

    // 暴露函数给父窗口
    window.performSearch = performSearch;
    window.applyAdvancedSearch = applyAdvancedSearch;
    window.shareFile = shareFile;
    window.toggleAdvancedSearch = toggleAdvancedSearch;
    window.hideSuggestPanel = hideSuggestPanel;
    window.deleteSearchHistoryFromDb = deleteSearchHistoryFromDb;
    window.selectHistoryKeyword = selectHistoryKeyword;
}

//搜索弹框重置
function resetAdvancedSearch() {
    // 重置时间范围：选择第一个选项（全部时间），并隐藏藏自定义时间输入框
    document.getElementById('timeRange').value = '';
    document.getElementById('customTime').style.display = 'none';
    document.getElementById('startDate').value = '';
    document.getElementById('endDate').value = '';

    // 重置文件大小：选择第一个选项（全部大小），并隐藏自定义大小输入框
    document.getElementById('fileSizeRange').value = '';
    document.getElementById('customSize').style.display = 'none';
    document.getElementById('minSize').value = '';
    document.getElementById('maxSize').value = '';

    // 重置文件类型：选择第一个选项（全部类型）
    document.getElementById('fileTypeFilter').value = '';

    // 重置排序方式：按时间（默认）且降序（默认）
    document.getElementById('sortBy').value = 'time';
    document.getElementById('sortOrder').value = 'desc';
}



// 修复shareFile函数（避免未定义报错）
function shareFile(fileId) {
    alert('分享功能待实现，文件ID: ' + fileId);
}

// 显示退出登录菜单
function showLogoutMenu() {
    const logoutMenu = document.getElementById('logoutMenu');
    if (logoutMenu) {
        logoutMenu.style.display = logoutMenu.style.display === 'none' ? 'block' : 'none';
    }
}

// 退出登录
async function logout() {
    try {
        // 先清除本地存储和全局变量
        localStorage.removeItem('currentUser');
        localStorage.removeItem('isLoggedIn');
        localStorage.removeItem('currentUserId');

        // 清除全局变量
        currentUser = null;
        window.CURRENT_USER_ID = null;

        // 调用后端退出接口（销毁session）
        try {
            await fetch('/api/user/logout', {
                method: 'GET',
                credentials: 'include' // 确保携带cookie
            });
        } catch (e) {
            console.warn('后端退出接口调用失败，但继续执行退出流程:', e);
        }

        // 跳转到登录页
        window.location.href = '/login';
    } catch (error) {
        console.error('退出登录失败:', error);
        // 即使请求失败也清除本地数据并跳转
        localStorage.clear();
        window.location.href = '/login';
    }
}

// 点击外部区域关闭退出菜单
document.addEventListener('click', function(event) {
    const userSection = document.querySelector('.user-section');
    const logoutMenu = document.getElementById('logoutMenu');

    if (userSection && logoutMenu && !userSection.contains(event.target)) {
        logoutMenu.style.display = 'none';
    }
});